home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MPW Oberon 2.1168 / OInterfaces / AppleTalk.mod < prev    next >
Encoding:
Text File  |  1995-08-10  |  33.8 KB  |  935 lines  |  [TEXT/MPS ]
  1. (*
  2.      File:        AppleTalk.mod
  3.  
  4.      Contains:    AppleTalk Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs.applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. *)
  19.  
  20. (*$IF UNDEFINED OLDROUTINENAMES*)
  21. (*$SET OLDROUTINENAMES FALSE*)
  22. (*$END*)
  23. (*$TAGS-*)
  24. (*$CALLING PASCAL*)
  25. MODULE AppleTalk;
  26.  
  27. IMPORT SYSTEM, Types, OSUtils;
  28.  
  29. (* $PUSH*)
  30. (* $ALIGN MAC68K*)
  31. (* $LibExport+*)
  32.  
  33. CONST
  34. (* Driver unit and reference numbers (ADSP is dynamic) *)
  35.     mppUnitNum*                    = 9;                            (* MPP unit number *)
  36.     atpUnitNum*                    = 10;                            (* ATP unit number *)
  37.     xppUnitNum*                    = 40;                            (* XPP unit number *)
  38.     mppRefNum*                    = -10;                            (* MPP reference number *)
  39.     atpRefNum*                    = -11;                            (* ATP reference number *)
  40.     xppRefNum*                    = -41;                            (* XPP reference number *)
  41. (* .MPP csCodes *)
  42.     lookupReply*                    = 242;                            (* This command queued to ourself *)
  43.     writeLAP*                    = 243;                            (* Write out LAP packet *)
  44.     detachPH*                    = 244;                            (* Detach LAP protocol handler *)
  45.     attachPH*                    = 245;                            (* Attach LAP protocol handler *)
  46.     writeDDP*                    = 246;                            (* Write out DDP packet *)
  47.     closeSkt*                    = 247;                            (* Close DDP socket *)
  48.     openSkt*                        = 248;                            (* Open DDP socket *)
  49.     loadNBP*                        = 249;                            (* Load NBP command-executing code *)
  50.     lastResident*                = 249;                            (* Last resident command *)
  51.     confirmName*                    = 250;                            (* Confirm name *)
  52.     lookupName*                    = 251;                            (* Look up name on internet *)
  53.     removeName*                    = 252;                            (* Remove name from Names Table *)
  54.     registerName*                = 253;                            (* Register name in Names Table *)
  55.     killNBP*                        = 254;                            (* Kill outstanding NBP request *)
  56.  
  57.     unloadNBP*                    = 255;                            (* Unload NBP command code *)
  58.     setSelfSend*                    = 256;                            (* MPP*: Set to allow writes to self *)
  59.     SetMyZone*                    = 257;                            (* Set my zone name *)
  60.     GetATalkInfo*                = 258;                            (* get AppleTalk information *)
  61.     ATalkClosePrep*                = 259;                            (* AppleTalk close query *)
  62. (* .ATP csCodes *)
  63.     nSendRequest*                = 248;                            (* NSendRequest code *)
  64.     relRspCB*                    = 249;                            (* Release RspCB *)
  65.     closeATPSkt*                    = 250;                            (* Close ATP socket *)
  66.     addResponse*                    = 251;                            (* Add response code | Require open skt *)
  67.     sendResponse*                = 252;                            (* Send response code *)
  68.     getRequest*                    = 253;                            (* Get request code *)
  69.     openATPSkt*                    = 254;                            (* Open ATP socket *)
  70.     sendRequest*                    = 255;                            (* Send request code *)
  71.     relTCB*                        = 256;                            (* Release TCB *)
  72.     killGetReq*                    = 257;                            (* Kill GetRequest *)
  73.     killSendReq*                    = 258;                            (* Kill SendRequest *)
  74.     killAllGetReq*                = 259;                            (* Kill all getRequests for a skt *)
  75. (* .XPP csCodes *)
  76.     openSess*                    = 255;                            (* Open session *)
  77.     closeSess*                    = 254;                            (* Close session *)
  78.     userCommand*                    = 253;                            (* User command *)
  79.  
  80.     userWrite*                    = 252;                            (* User write *)
  81.     getStatus*                    = 251;                            (* Get status *)
  82.     afpCall*                        = 250;                            (* AFP command (buffer has command code) *)
  83.     getParms*                    = 249;                            (* Get parameters *)
  84.     abortOS*                        = 248;                            (* Abort open session request *)
  85.     closeAll*                    = 247;                            (* Close all open sessions *)
  86.     xCall*                        = 246;                            (* .XPP extended calls *)
  87. (* Transition Queue transition types *)
  88.     ATTransOpen*                    = 0;                            (*AppleTalk has opened*)
  89.     ATTransClose*                = 2;                            (*AppleTalk is about to close*)
  90.     ATTransClosePrep*            = 3;                            (*Is it OK to close AppleTalk ?*)
  91.     ATTransCancelClose*            = 4;                            (*Cancel the ClosePrep transition*)
  92.     afpByteRangeLock*            = 1;                            (*AFPCall command codes*)
  93.     afpVolClose*                    = 2;                            (*AFPCall command codes*)
  94.     afpDirClose*                    = 3;                            (*AFPCall command codes*)
  95.     afpForkClose*                = 4;                            (*AFPCall command codes*)
  96.     afpCopyFile*                    = 5;                            (*AFPCall command codes*)
  97.     afpDirCreate*                = 6;                            (*AFPCall command codes*)
  98.     afpFileCreate*                = 7;                            (*AFPCall command codes*)
  99.     afpDelete*                    = 8;                            (*AFPCall command codes*)
  100.     afpEnumerate*                = 9;                            (*AFPCall command codes*)
  101.  
  102.     afpFlush*                    = 10;                            (*AFPCall command codes*)
  103.     afpForkFlush*                = 11;                            (*AFPCall command codes*)
  104.     afpGetDirParms*                = 12;                            (*AFPCall command codes*)
  105.     afpGetFileParms*                = 13;                            (*AFPCall command codes*)
  106.     afpGetForkParms*                = 14;                            (*AFPCall command codes*)
  107.     afpGetSInfo*                    = 15;                            (*AFPCall command codes*)
  108.     afpGetSParms*                = 16;                            (*AFPCall command codes*)
  109.     afpGetVolParms*                = 17;                            (*AFPCall command codes*)
  110.     afpLogin*                    = 18;                            (*AFPCall command codes*)
  111.     afpContLogin*                = 19;                            (*AFPCall command codes*)
  112.     afpLogout*                    = 20;                            (*AFPCall command codes*)
  113.     afpMapID*                    = 21;                            (*AFPCall command codes*)
  114.     afpMapName*                    = 22;                            (*AFPCall command codes*)
  115.     afpMove*                        = 23;                            (*AFPCall command codes*)
  116.     afpOpenVol*                    = 24;                            (*AFPCall command codes*)
  117.     afpOpenDir*                    = 25;                            (*AFPCall command codes*)
  118.     afpOpenFork*                    = 26;                            (*AFPCall command codes*)
  119.     afpRead*                        = 27;                            (*AFPCall command codes*)
  120.     afpRename*                    = 28;                            (*AFPCall command codes*)
  121.     afpSetDirParms*                = 29;                            (*AFPCall command codes*)
  122.  
  123.     afpSetFileParms*                = 30;                            (*AFPCall command codes*)
  124.     afpSetForkParms*                = 31;                            (*AFPCall command codes*)
  125.     afpSetVolParms*                = 32;                            (*AFPCall command codes*)
  126.     afpWrite*                    = 33;                            (*AFPCall command codes*)
  127.     afpGetFlDrParms*                = 34;                            (*AFPCall command codes*)
  128.     afpSetFlDrParms*                = 35;                            (*AFPCall command codes*)
  129.     afpDTOpen*                    = 48;                            (*AFPCall command codes*)
  130.     afpDTClose*                    = 49;                            (*AFPCall command codes*)
  131.     afpGetIcon*                    = 51;                            (*AFPCall command codes*)
  132.     afpGtIcnInfo*                = 52;                            (*AFPCall command codes*)
  133.     afpAddAPPL*                    = 53;                            (*AFPCall command codes*)
  134.     afpRmvAPPL*                    = 54;                            (*AFPCall command codes*)
  135.     afpGetAPPL*                    = 55;                            (*AFPCall command codes*)
  136.     afpAddCmt*                    = 56;                            (*AFPCall command codes*)
  137.     afpRmvCmt*                    = 57;                            (*AFPCall command codes*)
  138.     afpGetCmt*                    = 58;                            (*AFPCall command codes*)
  139.     afpAddIcon*                    = 192;                            (*Special code for ASP Write commands*)
  140.     xppLoadedBit*                = 5;                            (* XPP bit in PortBUse *)
  141.     scbMemSize*                    = 192;                            (* Memory.Size of memory for SCB *)
  142.     xppFlagClr*                    = 0;                            (* Cs for AFPCommandBlock *)
  143.  
  144.     xppFlagSet*                    = 128;                            (* StartEndFlag & NewLineFlag fields. *)
  145.     lapSize*                        = 20;
  146.     ddpSize*                        = 26;
  147.     nbpSize*                        = 26;
  148.     atpSize*                        = 56;
  149.     atpXOvalue*                    = 32;                            (*ATP exactly-once bit *)
  150.     atpEOMvalue*                    = 16;                            (*ATP End-Of-Message bit *)
  151.     atpSTSvalue*                    = 8;                            (*ATP Send-Transmission-Status bit *)
  152.     atpTIDValidvalue*            = 2;                            (*ATP trans. AIFF.ID valid bit *)
  153.     atpSendChkvalue*                = 1;                            (*ATP send checksum bit *)
  154.     zipGetLocalZones*            = 5;
  155.     zipGetZoneList*                = 6;
  156.     zipGetMyZone*                = 7;
  157.     LAPMgrPtr*                    = $B18;                            (*Entry point for LAP Manager*)
  158.     LAPMgrCall*                    = 2;                            (*Offset to LAP routines*)
  159.     LAddAEQ*                        = 23;                            (*LAPAddATQ routine selector*)
  160.     LRmvAEQ*                        = 24;                            (*LAPRmvATQ routine selector*)
  161.  
  162.     tLAPRead*                    = 0;
  163.     tLAPWrite*                    = 1;
  164.     tDDPRead*                    = 2;
  165.     tDDPWrite*                    = 3;
  166.     tNBPLookup*                    = 4;
  167.     tNBPConfirm*                    = 5;
  168.     tNBPRegister*                = 6;
  169.     tATPSndRequest*                = 7;
  170.     tATPGetRequest*                = 8;
  171.     tATPSdRsp*                    = 9;
  172.     tATPAddRsp*                    = 10;
  173.     tATPRequest*                    = 11;
  174.     tATPResponse*                = 12;
  175.  
  176.     
  177. TYPE
  178.     ABCallType* = Types.SInt8;
  179.  
  180.  
  181. CONST
  182.     lapProto*                    = 0;
  183.     ddpProto*                    = 1;
  184.     nbpProto*                    = 2;
  185.     atpProto*                    = 3;
  186.  
  187.     
  188. TYPE
  189.     ABProtoType* = Types.UInt8;
  190.  
  191.     ABByte* = Types.Byte;
  192.  
  193.     LAPAdrBlock* = (*ΔΔPACKEDΔΔ*) RECORD
  194.         dstNodeID*:                Types.UInt8;
  195.         srcNodeID*:                Types.UInt8;
  196.         lapProtType*:            ABByte;
  197.         filler*:                    Types.UInt8;                                    (*    Filler for proper byte alignment*)
  198.     END;
  199.  
  200.     ATQEntryPtr* = POINTER TO ATQEntry;
  201.  
  202.     ATalkTransitionEventProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (eventCode: LONGINT; qElem: ATQEntryPtr; eventParameter: (*ΔΔUNIVΔΔ*) Types.Ptr): LONGINT;
  203.     ATalkTransitionEventUPP* = Types.UniversalProcPtr;
  204.  
  205.     ATalkTransitionEvent* = ATalkTransitionEventUPP;
  206.  
  207.     ATQEntry* = RECORD
  208.         qLink*:                    OSUtils.QElemPtr (*ΔΔ POINTER TO ATQEntry*);                                (*next queue entry*)
  209.         qType*:                    INTEGER;                                (*queue type*)
  210.         CallAddr*:                ATalkTransitionEventUPP;                (*your routine descriptor*)
  211.     END;
  212.  
  213.     AddrBlock* = RECORD
  214.         aNet*:                    Types.UInt16;
  215.         aNode*:                    Types.SInt8; (* UInt8 *)
  216.         aSocket*:                Types.SInt8; (* UInt8 *)
  217.     END;
  218.  
  219. (* Real definition of EntityName is 3 (*ΔΔPACKEDΔΔ*) strings of any length (32 is just an example). No
  220. offests for Asm since each String address must be calculated by adding length byte to last string ptr.
  221. In Pascal, String(32) will be 34 bytes long since fields never start on an odd byte unless they are 
  222. only a byte long. So this will generate correct looking interfaces for Pascal and C, but they will not
  223. be the same, which is OK since they are not used. *)
  224.     EntityName* = RECORD
  225.         objStr*:                    Types.Str32;
  226.         pad1*:                    Types.SInt8;                                    (*Types.Str32's aligned on even word boundries.*)
  227.         typeStr*:                Types.Str32;
  228.         pad2*:                    Types.SInt8;
  229.         zoneStr*:                Types.Str32;
  230.         pad3*:                    Types.SInt8;
  231.     END;
  232.  
  233.     EntityPtr* = POINTER TO EntityName;
  234.  
  235.     RetransType* = (*ΔΔPACKEDΔΔ*) RECORD
  236.         retransInterval*:        Types.UInt8;
  237.         retransCount*:            Types.UInt8;
  238.     END;
  239.  
  240.     BDSElement* = RECORD
  241.         buffSize*:                INTEGER;
  242.         buffPtr*:                Types.Ptr;
  243.         dataSize*:                INTEGER;
  244.         userBytes*:                LONGINT;
  245.     END;
  246.  
  247.     BDSType* = ARRAY 8 (*ΔΔ[0..7]ΔΔ*) OF BDSElement;
  248.  
  249.     BDSPtr* = POINTER TO BDSElement;
  250.  
  251.     BitMapType* = SHORTINT (*ΔΔ PACKED ARRAY [0..7] OF BOOLEAN*);
  252.  
  253.     ATProtRec* = RECORD (*ΔΔ NEW*)
  254.         abOpcode*:                ABCallType;
  255.         filler*:                    Types.SInt8;                                    (*    Filler for proper byte alignment*)
  256.         abResult*:                INTEGER;
  257.         abUserReference*:        LONGINT;
  258.     END;
  259.  
  260.     ATLAPRec* = RECORD(ATProtRec)
  261.         (*ΔΔ abOpcode*:                ABCallType;
  262.         filler*:                    Types.SInt8;                                    (*    Filler for proper byte alignment*)
  263.         abResult*:                INTEGER;
  264.         abUserReference*:        LONGINT;*)
  265.         lapAddress*:                LAPAdrBlock;
  266.         lapReqCount*:            INTEGER;
  267.         lapActCount*:            INTEGER;
  268.         lapDataPtr*:                Types.Ptr;
  269.     END;
  270.  
  271.     ATLAPRecPtr* = POINTER TO ATLAPRec;
  272.     ATLAPRecHandle* = HANDLE TO ATLAPRec (*ΔΔ POINTER TO ATLAPRecPtr*);
  273.  
  274.     ATDDPRec* = RECORD(ATProtRec)
  275.         (*ΔΔ abOpcode*:                ABCallType;
  276.         filler*:                    Types.SInt8;                                    (*    Filler for proper byte alignment*)
  277.         abResult*:                INTEGER;
  278.         abUserReference*:        LONGINT;*)
  279.         ddpType*:                INTEGER;
  280.         ddpSocket*:                INTEGER;
  281.         ddpAddress*:                AddrBlock;
  282.         ddpReqCount*:            INTEGER;
  283.         ddpActCount*:            INTEGER;
  284.         ddpDataPtr*:                Types.Ptr;
  285.         ddpNodeID*:                INTEGER;
  286.     END;
  287.  
  288.     ATDDPRecPtr* = POINTER TO ATDDPRec;
  289.     ATDDPRecHandle* = HANDLE TO ATDDPRec (*ΔΔ POINTER TO ATDDPRecPtr*);
  290.  
  291.     ATNBPRec* = RECORD(ATProtRec)
  292.         (*ΔΔ abOpcode*:                ABCallType;
  293.         filler*:                    Types.SInt8;                                    (*    Filler for proper byte alignment*)
  294.         abResult*:                INTEGER;
  295.         abUserReference*:        LONGINT;*)
  296.         nbpEntityPtr*:            EntityPtr;
  297.         nbpBufPtr*:                Types.Ptr;
  298.         nbpBufSize*:                INTEGER;
  299.         nbpDataField*:            INTEGER;
  300.         nbpAddress*:                AddrBlock;
  301.         nbpRetransmitInfo*:        RetransType;
  302.     END;
  303.  
  304.     ATNBPRecPtr* = POINTER TO ATNBPRec;
  305.     ATNBPRecHandle* = HANDLE TO ATNBPRec (*ΔΔ POINTER TO ATNBPRecPtr*);
  306.  
  307.     ATATPRec* = RECORD(ATProtRec)
  308.         (*ΔΔ abOpcode*:                ABCallType;
  309.         filler1*:                Types.SInt8;                                    (*    Filler for proper byte alignment*)
  310.         abResult*:                INTEGER;
  311.         abUserReference*:        LONGINT;*)
  312.         atpSocket*:                INTEGER;
  313.         atpAddress*:                AddrBlock;
  314.         atpReqCount*:            INTEGER;
  315.         atpDataPtr*:                Types.Ptr;
  316.         atpRspBDSPtr*:            BDSPtr;
  317.         atpBitMap*:                BitMapType;
  318.         filler2*:                Types.SInt8; (* UInt8 *)                        (*    Filler for proper byte alignment*)
  319.         atpTransID*:                INTEGER;
  320.         atpActCount*:            INTEGER;
  321.         atpUserData*:            LONGINT;
  322.         atpXO*:                    BOOLEAN;
  323.         atpEOM*:                    BOOLEAN;
  324.         atpTimeOut*:                INTEGER;
  325.         atpRetries*:                INTEGER;
  326.         atpNumBufs*:                INTEGER;
  327.         atpNumRsp*:                INTEGER;
  328.         atpBDSSize*:                INTEGER;
  329.         atpRspUData*:            LONGINT;
  330.         atpRspBuf*:                Types.Ptr;
  331.         atpRspSize*:                INTEGER;
  332.     END;
  333.  
  334.     ATATPRecPtr* = POINTER TO ATATPRec;
  335.     ATATPRecHandle* = HANDLE TO ATATPRec (*ΔΔ POINTER TO ATATPRecPtr*);
  336.  
  337.     AFPCommandBlock* = (*ΔΔPACKEDΔΔ*) RECORD
  338.         cmdByte*:                Types.UInt8;
  339.         startEndFlag*:            Types.UInt8;
  340.         forkRefNum*:                INTEGER;
  341.         rwOffset*:                LONGINT;
  342.         reqCount*:                LONGINT;
  343.         newLineFlag*:            Types.UInt8;
  344.         newLineChar*:            CHAR;
  345.     END;
  346.  
  347.     MPPPBPtr* = POINTER TO MPPParamBlock;
  348.  
  349.     ATPPBPtr* = POINTER TO ATPParamBlock;
  350.  
  351.     XPPParmBlkPtr* = POINTER TO XPPParamBlock;
  352.  
  353.     (*
  354.         MPPCompletionProcPtr uses register based parameters on the 68k and cannot
  355.         be written in or called from a high-level language without the help of
  356.         mixed mode or assembly glue.
  357.  
  358.         In:
  359.          => thePBptr        A0.L
  360.     *)
  361.     MPPCompletionProcPtr* = Types.Register68kProcPtr;  (* register PROCEDURE MPPCompletion*(thePBptr: MPPPBPtr); *)
  362.     (*
  363.         ATPCompletionProcPtr uses register based parameters on the 68k and cannot
  364.         be written in or called from a high-level language without the help of
  365.         mixed mode or assembly glue.
  366.  
  367.         In:
  368.          => thePBptr        A0.L
  369.     *)
  370.     ATPCompletionProcPtr* = Types.Register68kProcPtr;  (* register PROCEDURE ATPCompletion*(thePBptr: ATPPBPtr); *)
  371.     (*
  372.         XPPCompletionProcPtr uses register based parameters on the 68k and cannot
  373.         be written in or called from a high-level language without the help of
  374.         mixed mode or assembly glue.
  375.  
  376.         In:
  377.          => thePBptr        A0.L
  378.     *)
  379.     XPPCompletionProcPtr* = Types.Register68kProcPtr;  (* register PROCEDURE XPPCompletion*(thePBptr: XPPParmBlkPtr); *)
  380.     (*
  381.         AttnRoutineProcPtr uses register based parameters on the 68k and cannot
  382.         be written in or called from a high-level language without the help of
  383.         mixed mode or assembly glue.
  384.  
  385.         In:
  386.          => sessRefnum      D0.W
  387.          => attnBytes       D1.W
  388.     *)
  389.     AttnRoutineProcPtr* = Types.Register68kProcPtr;  (* register PROCEDURE AttnRoutine*(sessRefnum: INTEGER; attnBytes*: INTEGER); *)
  390.     MPPCompletionUPP* = Types.UniversalProcPtr;
  391.     ATPCompletionUPP* = Types.UniversalProcPtr;
  392.     XPPCompletionUPP* = Types.UniversalProcPtr;
  393.     AttnRoutineUPP* = Types.UniversalProcPtr;
  394.  
  395.     WDSElement* = RECORD
  396.         entryLength*:            INTEGER;
  397.         entryPtr*:                Types.Ptr;
  398.     END;
  399.  
  400.     NTElement* = RECORD
  401.         nteAddress*:                AddrBlock;                                (*network address of entity*)
  402.         filler*:                    Types.SInt8;
  403.         entityData*:                (*ΔΔPACKEDΔΔ*) ARRAY 99 (*ΔΔ[0..98]ΔΔ*) OF Types.SInt8;            (*Object, Type & Memory.Zone*)
  404.     END;
  405.  
  406.     NamesTableEntry* = RECORD
  407.         qNext*:                    Types.Ptr;                                    (*ptr to next NTE*)
  408.         nt*:                        NTElement;
  409.     END;
  410.  
  411.     MPPProtocolHandlerProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (SCCAddr1: Types.Ptr; SCCAddr2: Types.Ptr; MPPLocalVars: Types.Ptr; nextFreeByteInRHA: Types.Ptr; ReadPacketAndReadRestPtr: Types.Ptr; numBytesLeftToReadInPacket: INTEGER): BOOLEAN;
  412.     DDPSocketListenerProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (SCCAddr1: Types.Ptr; SCCAddr2: Types.Ptr; MPPLocalVars: Types.Ptr; nextFreeByteInRHA: Types.Ptr; ReadPacketAndReadRestPtr: Types.Ptr; packetDestinationNumber: Types.ByteParameter; numBytesLeftToReadInPacket: INTEGER): BOOLEAN;
  413.     MPPProtocolHandlerUPP* = Types.UniversalProcPtr;
  414.     DDPSocketListenerUPP* = Types.UniversalProcPtr;
  415.  
  416.     MPPParamBlock* = RECORD(OSUtils.QElem)
  417.         (*ΔΔ qLink*:                    OSUtils.QElemPtr (*ΔΔ POINTER TO OSUtils.QElem*);
  418.         qType*:                    INTEGER;*)
  419.         ioTrap*:                    INTEGER;
  420.         ioCmdAddr*:                Types.Ptr;
  421.         ioCompletion*:            ATPCompletionUPP;
  422.         ioResult*:                Types.OSErr;
  423.         userData*:                LONGINT;
  424.         reqTID*:                    INTEGER;
  425.         ioRefNum*:                INTEGER;
  426.         csCode*:                    INTEGER;
  427.         (*ΔΔ CASE INTEGER OF
  428.         0: ( *)
  429.     END;
  430.     LAPWPBPtr* = POINTER TO LAPWriteParamBlock;
  431.     LAPWriteParamBlock* = RECORD(MPPParamBlock)
  432.             filler0*:                    INTEGER;
  433.             wdsPointer*:                    Types.Ptr;
  434.            (*ΔΔ );
  435.         1: ( *)
  436.     END;
  437.     PHPBPtr* = POINTER TO ProtocolHandlerParamBlock;
  438.     ProtocolHandlerParamBlock* = RECORD(MPPParamBlock)
  439.             protType*:                    Types.SInt8; (* UInt8 *)
  440.             filler*:                        Types.SInt8; (* UInt8 *)
  441.             handler*:                    MPPProtocolHandlerUPP;
  442.            (*ΔΔ );
  443.         2: ( *)
  444.     END;
  445.     SocketPBPtr* = POINTER TO SocketDDPParamBlock;
  446.     SocketDDPParamBlock* = RECORD(MPPParamBlock)
  447.             socket*:                        Types.SInt8; (* UInt8 *)
  448.             checksumFlag*:                Types.SInt8; (* UInt8 *)
  449.             listener*:                    DDPSocketListenerUPP;
  450.            (*ΔΔ );
  451.         3: ( *)
  452.     END;
  453.     NBPPBPtr* = POINTER TO NBPParamBlock;
  454.     NBPParamBlock* = RECORD(MPPParamBlock)
  455.             interval*:                    Types.SInt8; (* UInt8 *)                    (*retry interval *)
  456.             count*:                        Types.SInt8; (* UInt8 *)                    (*retry count *)
  457.             nbpPtrs*:                    Types.Ptr;
  458.             (*ΔΔ CASE INTEGER OF
  459.             0: ( *)
  460.     END;
  461.     RegisterPBPtr* = POINTER TO RegisterParamBlock;
  462.     RegisterParamBlock* = RECORD(NBPParamBlock)
  463.                 verifyFlag*:                        Types.SInt8; (* UInt8 *)
  464.                 filler3*:                        Types.SInt8; (* UInt8 *)
  465.                (*ΔΔ );
  466.             1: ( *)
  467.     END;
  468.     LookupPBPtr* = POINTER TO LookupWriteParamBlock;
  469.     LookupWriteParamBlock* = RECORD(NBPParamBlock)
  470.                 retBuffPtr*:                        Types.Ptr;
  471.                 retBuffSize*:                    INTEGER;
  472.                 maxToGet*:                        INTEGER;
  473.                 numGotten*:                        INTEGER;
  474.                (*ΔΔ );
  475.             2: ( *)
  476.     END;
  477.     ConfirmPBPtr* = POINTER TO ConfirmParamBlock;
  478.     ConfirmParamBlock* = RECORD(NBPParamBlock)
  479.                 confirmAddr*:                    AddrBlock;
  480.                 newSocket*:                        Types.SInt8; (* UInt8 *)
  481.                 filler4*:                        Types.SInt8; (* UInt8 *)
  482.                (*ΔΔ );
  483.            );
  484.         4: ( *)
  485.     END;
  486.     SelfSendPBPtr* = POINTER TO SelfSendParamBlock;
  487.     SelfSendParamBlock* = RECORD(MPPParamBlock)
  488.             newSelfFlag*:                Types.SInt8; (* UInt8 *)                    (*self-send toggle flag *)
  489.             oldSelfFlag*:                Types.SInt8; (* UInt8 *)                    (*previous self-send state *)
  490.            (*ΔΔ );
  491.         5: ( *)
  492.     END;
  493.     KillNBPPBPtr* = POINTER TO KillNBPParamBlock;
  494.     KillNBPParamBlock* = RECORD(MPPParamBlock)
  495.             nKillQEl*:                    Types.Ptr;                                (*ptr to i/o queue element to cancel *)
  496.            (*ΔΔ );
  497.         6: ( *)
  498.     END;
  499.     GetATInfoPBPtr* = POINTER TO GetATInfoParamBlock;
  500.     GetATInfoParamBlock* = RECORD(MPPParamBlock)
  501.             version*:                    INTEGER;
  502.             varsPtr*:                    Types.Ptr;
  503.             DCEPtr*:                        Types.Ptr;
  504.             portID*:                        INTEGER;
  505.             configuration*:                LONGINT;
  506.             selfSend*:                    INTEGER;
  507.             netLo*:                        INTEGER;
  508.             netHi*:                        INTEGER;
  509.             ourAdd*:                        LONGINT;
  510.             routerAddr*:                    LONGINT;
  511.             numOfPHs*:                    INTEGER;
  512.             numOfSkts*:                    INTEGER;
  513.             numNBPEs*:                    INTEGER;
  514.             nTQueue*:                    Types.Ptr;
  515.             LAlength*:                    INTEGER;
  516.             linkAddr*:                    Types.Ptr;
  517.             zoneName*:                    Types.Ptr;
  518.            (*ΔΔ );
  519.         7: ( *)
  520.     END;
  521.     ATClosePrepPBPtr* = POINTER TO ATClosePrepParamBlock;
  522.     ATClosePrepParamBlock* = RECORD(MPPParamBlock)
  523.             appName*:                    Types.Ptr;                                (*pointer to application name in buffer*)
  524.            (*ΔΔ );*)
  525.     END;
  526.  
  527.     XPPParamBlock* = RECORD(OSUtils.QElem)
  528.         (*ΔΔ qLink*:                    OSUtils.QElemPtr (*ΔΔ POINTER TO OSUtils.QElem*);
  529.         qType*:                    INTEGER;*)
  530.         ioTrap*:                    INTEGER;
  531.         ioCmdAddr*:                Types.Ptr;
  532.         ioCompletion*:            XPPCompletionUPP;
  533.         ioResult*:                Types.OSErr;
  534.         cmdResult*:                LONGINT;
  535.         ioVRefNum*:                INTEGER;
  536.         ioRefNum*:                INTEGER;
  537.         csCode*:                    INTEGER;
  538.         (*ΔΔ CASE INTEGER OF
  539.         0: ( *)
  540.     END;
  541.     ASPAbortPBPtr* = POINTER TO ASPAbortParamBlock;
  542.     ASPAbortParamBlock* = RECORD(XPPParamBlock)
  543.             abortSCBPtr*:                Types.Ptr;                                (* SCB pointer for AbortOS*)
  544.            (*ΔΔ );
  545.         1: ( *)
  546.     END;
  547.     ASPSizePBPtr* = POINTER TO ASPSizeParamBlock;
  548.     ASPSizeParamBlock* = RECORD(XPPParamBlock)
  549.             aspMaxCmdSize*:                INTEGER;
  550.             aspQuantumSize*:                INTEGER;
  551.             numSesss*:                    INTEGER;
  552.            (*ΔΔ );
  553.         2: ( *)
  554.     END;
  555.     XPPXPBPtr* = POINTER TO XPPXParamBlock;
  556.     XPPXParamBlock* = RECORD(XPPParamBlock)
  557.             sessRefnum*:                    INTEGER;
  558.             aspTimeout*:                    Types.SInt8; (* UInt8 *)
  559.             aspRetry*:                    Types.SInt8; (* UInt8 *)
  560.             (*ΔΔ CASE INTEGER OF
  561.             0: ( *)
  562.     END;
  563.     ASPOpenPBPtr* = POINTER TO ASPOpenParamBlock;
  564.     ASPOpenParamBlock* = RECORD(XPPXParamBlock)
  565.                 serverAddr*:                        AddrBlock;
  566.                 scbPointer*:                        Types.Ptr;
  567.                 attnRoutine*:                    AttnRoutineUPP;
  568.                (*ΔΔ );
  569.             1: ( *)
  570.     END;
  571.     ASPSubPBPtr* = POINTER TO ASPSubParamBlock;
  572.     ASPSubParamBlock* = RECORD(XPPXParamBlock)
  573.                 cbSize*:                            INTEGER;
  574.                 cbPtr*:                            Types.Ptr;
  575.                 rbSize*:                            INTEGER;
  576.                 rbPtr*:                            Types.Ptr;
  577.                 (*ΔΔ CASE INTEGER OF
  578.                 0: ( *)
  579.     END;
  580.     AFPLoginPBPtr* = POINTER TO AFPLoginParamBlock;
  581.     AFPLoginParamBlock* = RECORD(ASPSubParamBlock)
  582.                     afpAddrBlock*:                        AddrBlock;
  583.                     afpSCBPtr*:                            Types.Ptr;
  584.                     afpAttnRoutine*:                        Types.Ptr;
  585.                    (*ΔΔ );
  586.                 1: ( *)
  587.     END;
  588.     ASPEndPBPtr* = POINTER TO ASPEndParamBlock;
  589.     ASPEndParamBlock* = RECORD(ASPSubParamBlock)
  590.                     wdSize*:                                INTEGER;
  591.                     wdPtr*:                                Types.Ptr;
  592.                     ccbStart*:                            ARRAY 296 (*ΔΔ[0..295]ΔΔ*) OF Types.SInt8; (* UInt8 *)
  593.                    (*ΔΔ );
  594.                );
  595.            );
  596.         3: ( *)
  597.     END;
  598.     XCallPBPtr* = POINTER TO XCallParamBlock;
  599.     XCallParamBlock* = RECORD(XPPParamBlock)
  600.             xppSubCode*:                    INTEGER;
  601.             xppTimeout*:                    Types.SInt8; (* UInt8 *)
  602.             xppRetry*:                    Types.SInt8; (* UInt8 *)
  603.             filler1*:                    INTEGER;
  604.             zipBuffPtr*:                    Types.Ptr;
  605.             zipNumZones*:                INTEGER;
  606.             zipLastFlag*:                Types.SInt8; (* UInt8 *)
  607.             filler2*:                    Types.SInt8; (* UInt8 *)
  608.             zipInfoField*:                (*ΔΔPACKEDΔΔ*) ARRAY 70 (*ΔΔ[0..69]ΔΔ*) OF Types.SInt8; (* UInt8 *)
  609.            (*ΔΔ );*)
  610.     END;
  611.  
  612.     ATPParamBlock* = RECORD(OSUtils.QElem)
  613.         (*ΔΔ qLink*:                    OSUtils.QElemPtr (*ΔΔ POINTER TO OSUtils.QElem*);
  614.         qType*:                    INTEGER;*)
  615.         ioTrap*:                    INTEGER;
  616.         ioCmdAddr*:                Types.Ptr;
  617.         ioCompletion*:            ATPCompletionUPP;
  618.         ioResult*:                Types.OSErr;
  619.         userData*:                LONGINT;
  620.         reqTID*:                    INTEGER;
  621.         ioRefNum*:                INTEGER;
  622.         csCode*:                    INTEGER;
  623.         atpSocket*:                Types.SInt8; (* UInt8 *)
  624.         atpFlags*:                Types.SInt8; (* UInt8 *)
  625.         addrBlock*:                AddrBlock;
  626.         reqLength*:                INTEGER;
  627.         reqPointer*:                Types.Ptr;
  628.         bdsPointer*:                Types.Ptr;
  629.         (*ΔΔ CASE INTEGER OF
  630.         0: ( *)
  631.     END;
  632.     SendRequestPBPtr* = POINTER TO SendRequestParamBlock;
  633.     SendRequestParamBlock* = RECORD(ATPParamBlock)
  634.             numOfBuffs*:                    Types.SInt8; (* UInt8 *)
  635.             timeOutVal*:                    Types.SInt8; (* UInt8 *)
  636.             numOfResps*:                    Types.SInt8; (* UInt8 *)
  637.             retryCount*:                    Types.SInt8; (* UInt8 *)
  638.             intBuff*:                    INTEGER;
  639.             TRelTime*:                    Types.SInt8; (* UInt8 *)
  640.            (*ΔΔ );
  641.         1: ( *)
  642.     END;
  643.     SendResponsePBPtr* = POINTER TO SendResponseParamBlock;
  644.     SendResponseParamBlock* = RECORD(ATPParamBlock)
  645.             filler*:                        Types.SInt8; (* UInt8 *)
  646.             bdsSize*:                    Types.SInt8; (* UInt8 *)
  647.             transID*:                    INTEGER;
  648.            (*ΔΔ );
  649.         2: ( *)
  650.     END;
  651.     GetRequestPBPtr* = POINTER TO GetRequestParamBlock;
  652.     GetRequestParamBlock* = RECORD(ATPParamBlock)
  653.             bitMap*:                        Types.SInt8; (* UInt8 *)
  654.             filler2*:                    Types.SInt8; (* UInt8 *)
  655.            (*ΔΔ );
  656.         3: ( *)
  657.     END;
  658.     AddResponsePBPtr* = POINTER TO AddResponseParamBlock;
  659.     AddResponseParamBlock* = RECORD(ATPParamBlock)
  660.             rspNum*:                        Types.SInt8; (* UInt8 *)
  661.             filler3*:                    Types.SInt8; (* UInt8 *)
  662.            (*ΔΔ );
  663.         4: ( *)
  664.     END;
  665.     KillSendReqPBPtr* = POINTER TO KillSendReqParamBlock;
  666.     KillSendReqParamBlock* = RECORD(ATPParamBlock)
  667.             aKillQEl*:                    Types.Ptr;
  668.            (*ΔΔ );*)
  669.     END;
  670.  
  671.  
  672. CONST
  673.     uppATalkTransitionEventProcInfo* = $00000FF1; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
  674.     uppMPPCompletionProcInfo* = $00009802; (* Register PROCEDURE (4 bytes in A0); *)
  675.     uppATPCompletionProcInfo* = $00009802; (* Register PROCEDURE (4 bytes in A0); *)
  676.     uppXPPCompletionProcInfo* = $00009802; (* Register PROCEDURE (4 bytes in A0); *)
  677.     uppAttnRoutineProcInfo* = $00061002; (* Register PROCEDURE (2 bytes in D0, 2 bytes in D1); *)
  678.     uppMPPProtocolHandlerProcInfo* = $0000007F; (* SPECIAL_CASE_PROCINFO( kSpecialCaseProtocolHandler ) *)
  679.     uppDDPSocketListenerProcInfo* = $0000008F; (* SPECIAL_CASE_PROCINFO( kSpecialCaseSocketListener ) *)
  680.  
  681. PROCEDURE NewATalkTransitionEventProc*(userRoutine: ATalkTransitionEventProcPtr): ATalkTransitionEventUPP;
  682.     (*$IF NOT GENERATINGCFM *)
  683.     INLINE PASCAL $2E9F;
  684.     (*$END*)
  685.  
  686. PROCEDURE NewMPPCompletionProc*(userRoutine: MPPCompletionProcPtr): MPPCompletionUPP;
  687.     (*$IF NOT GENERATINGCFM *)
  688.     INLINE PASCAL $2E9F;
  689.     (*$END*)
  690.  
  691. PROCEDURE NewATPCompletionProc*(userRoutine: ATPCompletionProcPtr): ATPCompletionUPP;
  692.     (*$IF NOT GENERATINGCFM *)
  693.     INLINE PASCAL $2E9F;
  694.     (*$END*)
  695.  
  696. PROCEDURE NewXPPCompletionProc*(userRoutine: XPPCompletionProcPtr): XPPCompletionUPP;
  697.     (*$IF NOT GENERATINGCFM *)
  698.     INLINE PASCAL $2E9F;
  699.     (*$END*)
  700.  
  701. PROCEDURE NewAttnRoutineProc*(userRoutine: AttnRoutineProcPtr): AttnRoutineUPP;
  702.     (*$IF NOT GENERATINGCFM *)
  703.     INLINE PASCAL $2E9F;
  704.     (*$END*)
  705.  
  706. PROCEDURE NewMPPProtocolHandlerProc*(userRoutine: MPPProtocolHandlerProcPtr): MPPProtocolHandlerUPP;
  707.     (*$IF NOT GENERATINGCFM *)
  708.     INLINE PASCAL $2E9F;
  709.     (*$END*)
  710.  
  711. PROCEDURE NewDDPSocketListenerProc*(userRoutine: DDPSocketListenerProcPtr): DDPSocketListenerUPP;
  712.     (*$IF NOT GENERATINGCFM *)
  713.     INLINE PASCAL $2E9F;
  714.     (*$END*)
  715.  
  716. PROCEDURE CallATalkTransitionEventProc*(eventCode: LONGINT; qElem: ATQEntryPtr; eventParameter: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: ATalkTransitionEventUPP): LONGINT;
  717.     (*$IF NOT GENERATINGCFM*)
  718.     INLINE PASCAL $205F, $4E90;
  719.     (*$END*)
  720.  
  721. PROCEDURE CallMPPCompletionProc*(thePBptr: MPPPBPtr; userRoutine: MPPCompletionUPP);
  722.     (*$IF NOT GENERATINGCFM*)
  723.     INLINE PASCAL ; (*••*)
  724.     (*To be implemented:  Glue to move parameters into registers.*)
  725.     (*$END*)
  726.  
  727. PROCEDURE CallATPCompletionProc*(thePBptr: ATPPBPtr; userRoutine: ATPCompletionUPP);
  728.     (*$IF NOT GENERATINGCFM*)
  729.     INLINE PASCAL ; (*••*)
  730.     (*To be implemented:  Glue to move parameters into registers.*)
  731.     (*$END*)
  732.  
  733. PROCEDURE CallXPPCompletionProc*(thePBptr: XPPParmBlkPtr; userRoutine: XPPCompletionUPP);
  734.     (*$IF NOT GENERATINGCFM*)
  735.     INLINE PASCAL ; (*••*)
  736.     (*To be implemented:  Glue to move parameters into registers.*)
  737.     (*$END*)
  738.  
  739. PROCEDURE CallAttnRoutineProc*(sessRefnum: INTEGER; attnBytes: INTEGER; userRoutine: AttnRoutineUPP);
  740.     (*$IF NOT GENERATINGCFM*)
  741.     INLINE PASCAL ; (*••*)
  742.     (*To be implemented:  Glue to move parameters into registers.*)
  743.     (*$END*)
  744.  
  745. PROCEDURE CallMPPProtocolHandlerProc*(SCCAddr1: Types.Ptr; SCCAddr2: Types.Ptr; MPPLocalVars: Types.Ptr; nextFreeByteInRHA: Types.Ptr; ReadPacketAndReadRestPtr: Types.Ptr; numBytesLeftToReadInPacket: INTEGER; userRoutine: MPPProtocolHandlerUPP): BOOLEAN;
  746.     (*$IF NOT GENERATINGCFM*)
  747.     INLINE PASCAL ; (*••*)
  748.     (*To be implemented:  Glue to move parameters according to special case conventions.*)
  749.     (*$END*)
  750.  
  751. PROCEDURE CallDDPSocketListenerProc*(SCCAddr1: Types.Ptr; SCCAddr2: Types.Ptr; MPPLocalVars: Types.Ptr; nextFreeByteInRHA: Types.Ptr; ReadPacketAndReadRestPtr: Types.Ptr; packetDestinationNumber: Types.ByteParameter; numBytesLeftToReadInPacket: INTEGER; userRoutine: DDPSocketListenerUPP): BOOLEAN;
  752.     (*$IF NOT GENERATINGCFM*)
  753.     INLINE PASCAL ; (*••*)
  754.     (*To be implemented:  Glue to move parameters according to special case conventions.*)
  755.     (*$END*)
  756.  
  757. PROCEDURE OpenXPP*(VAR xppRefnum: INTEGER): Types.OSErr;
  758.     EXTERNAL PASCAL;
  759. PROCEDURE ASPOpenSession*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  760.     EXTERNAL PASCAL;
  761. PROCEDURE ASPCloseSession*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  762.     EXTERNAL PASCAL;
  763. PROCEDURE ASPAbortOS*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  764.     EXTERNAL PASCAL;
  765. PROCEDURE ASPGetParms*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  766.     EXTERNAL PASCAL;
  767. PROCEDURE ASPCloseAll*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  768.     EXTERNAL PASCAL;
  769. PROCEDURE ASPUserWrite*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  770.     EXTERNAL PASCAL;
  771. PROCEDURE ASPUserCommand*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  772.     EXTERNAL PASCAL;
  773. PROCEDURE ASPGetStatus*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  774.     EXTERNAL PASCAL;
  775. PROCEDURE AFPCommand*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  776.     EXTERNAL PASCAL;
  777. PROCEDURE GetLocalZones*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  778.     EXTERNAL PASCAL;
  779. PROCEDURE GetZoneList*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  780.     EXTERNAL PASCAL;
  781. PROCEDURE GetMyZone*(thePBptr: XPPParmBlkPtr; async: BOOLEAN): Types.OSErr;
  782.     EXTERNAL PASCAL;
  783. PROCEDURE PAttachPH*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  784.     EXTERNAL PASCAL;
  785. PROCEDURE PDetachPH*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  786.     EXTERNAL PASCAL;
  787. PROCEDURE PWriteLAP*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  788.     EXTERNAL PASCAL;
  789. PROCEDURE POpenSkt*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  790.     EXTERNAL PASCAL;
  791. PROCEDURE PCloseSkt*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  792.     EXTERNAL PASCAL;
  793. PROCEDURE PWriteDDP*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  794.     EXTERNAL PASCAL;
  795. PROCEDURE PRegisterName*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  796.     EXTERNAL PASCAL;
  797. PROCEDURE PLookupName*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  798.     EXTERNAL PASCAL;
  799. PROCEDURE PConfirmName*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  800.     EXTERNAL PASCAL;
  801. PROCEDURE PRemoveName*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  802.     EXTERNAL PASCAL;
  803. PROCEDURE PSetSelfSend*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  804.     EXTERNAL PASCAL;
  805. PROCEDURE PKillNBP*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  806.     EXTERNAL PASCAL;
  807. PROCEDURE PGetAppleTalkInfo*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  808.     EXTERNAL PASCAL;
  809. PROCEDURE PATalkClosePrep*(thePBptr: MPPPBPtr; async: BOOLEAN): Types.OSErr;
  810.     EXTERNAL PASCAL;
  811. PROCEDURE POpenATPSkt*(thePBptr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  812.     EXTERNAL PASCAL;
  813. PROCEDURE PCloseATPSkt*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  814.     EXTERNAL PASCAL;
  815. PROCEDURE PSendRequest*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  816.     EXTERNAL PASCAL;
  817. PROCEDURE PGetRequest*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  818.     EXTERNAL PASCAL;
  819. PROCEDURE PSendResponse*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  820.     EXTERNAL PASCAL;
  821. PROCEDURE PAddResponse*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  822.     EXTERNAL PASCAL;
  823. PROCEDURE PRelTCB*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  824.     EXTERNAL PASCAL;
  825. PROCEDURE PRelRspCB*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  826.     EXTERNAL PASCAL;
  827. PROCEDURE PNSendRequest*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  828.     EXTERNAL PASCAL;
  829. PROCEDURE PKillSendReq*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  830.     EXTERNAL PASCAL;
  831. PROCEDURE PKillGetReq*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  832.     EXTERNAL PASCAL;
  833. PROCEDURE ATPKillAllGetReq*(thePBPtr: ATPPBPtr; async: BOOLEAN): Types.OSErr;
  834.     EXTERNAL PASCAL;
  835. PROCEDURE BuildLAPwds*(wdsPtr: Types.Ptr; dataPtr: Types.Ptr; destHost: INTEGER; prototype: INTEGER; frameLen: INTEGER);
  836.     EXTERNAL PASCAL;
  837. PROCEDURE BuildDDPwds*(wdsPtr: Types.Ptr; headerPtr: Types.Ptr; dataPtr: Types.Ptr; netAddr: AddrBlock; ddpType: INTEGER; dataLen: INTEGER);
  838.     EXTERNAL PASCAL;
  839. PROCEDURE NBPSetEntity*(buffer: Types.Ptr; nbpObject: Types.ConstStr32Param; nbpType: Types.ConstStr32Param; nbpZone: Types.ConstStr32Param);
  840.     EXTERNAL PASCAL;
  841. PROCEDURE NBPSetNTE*(ntePtr: Types.Ptr; nbpObject: Types.ConstStr32Param; nbpType: Types.ConstStr32Param; nbpZone: Types.ConstStr32Param; socket: INTEGER);
  842.     EXTERNAL PASCAL;
  843. PROCEDURE GetBridgeAddress*(): INTEGER;
  844.     EXTERNAL PASCAL;
  845. PROCEDURE BuildBDS*(buffPtr: Types.Ptr; bdsPtr: Types.Ptr; buffSize: INTEGER): INTEGER;
  846.     EXTERNAL PASCAL;
  847. PROCEDURE MPPOpen*(): Types.OSErr;
  848.     EXTERNAL PASCAL;
  849. PROCEDURE LAPAddATQ*(theATQEntry: ATQEntryPtr): Types.OSErr;
  850.     EXTERNAL PASCAL;
  851. PROCEDURE LAPRmvATQ*(theATQEntry: ATQEntryPtr): Types.OSErr;
  852.     EXTERNAL PASCAL;
  853. PROCEDURE ATPLoad*(): Types.OSErr;
  854.     EXTERNAL PASCAL;
  855. PROCEDURE ATPUnload*(): Types.OSErr;
  856.     EXTERNAL PASCAL;
  857. PROCEDURE NBPExtract*(theBuffer: Types.Ptr; numInBuf: INTEGER; whichOne: INTEGER; VAR abEntity: EntityName; VAR address: AddrBlock): Types.OSErr;
  858.     EXTERNAL PASCAL;
  859. PROCEDURE GetNodeAddress*(VAR myNode: INTEGER; VAR myNet: INTEGER): Types.OSErr;
  860.     EXTERNAL PASCAL;
  861. PROCEDURE IsMPPOpen*(): BOOLEAN;
  862.     EXTERNAL PASCAL;
  863. PROCEDURE IsATPOpen*(): BOOLEAN;
  864.     EXTERNAL PASCAL;
  865. PROCEDURE ATEvent*(event: LONGINT; infoPtr: Types.Ptr);
  866.     EXTERNAL PASCAL;
  867. PROCEDURE ATPreFlightEvent*(event: LONGINT; cancel: LONGINT; infoPtr: Types.Ptr): Types.OSErr;
  868.     EXTERNAL PASCAL;
  869. (*
  870.     The following routines are obsolete and will not be supported on
  871.     PowerPC. Equivalent functionality is provided by the routines
  872.     above.
  873. *)
  874. (*$IF OLDROUTINENAMES AND NOT GENERATINGCFM *)
  875. PROCEDURE MPPClose*(): Types.OSErr;
  876.     EXTERNAL PASCAL;
  877. PROCEDURE LAPOpenProtocol*(theLAPType: Types.ByteParameter; protoPtr: Types.Ptr): Types.OSErr;
  878.     EXTERNAL PASCAL;
  879. PROCEDURE LAPCloseProtocol*(theLAPType: Types.ByteParameter): Types.OSErr;
  880.     EXTERNAL PASCAL;
  881. PROCEDURE LAPWrite*(abRecord: ATLAPRecHandle; async: BOOLEAN): Types.OSErr;
  882.     EXTERNAL PASCAL;
  883. PROCEDURE LAPRead*(abRecord: ATLAPRecHandle; async: BOOLEAN): Types.OSErr;
  884.     EXTERNAL PASCAL;
  885. PROCEDURE LAPRdCancel*(abRecord: ATLAPRecHandle): Types.OSErr;
  886.     EXTERNAL PASCAL;
  887. PROCEDURE DDPOpenSocket*(VAR theSocket: INTEGER; sktListener: Types.Ptr): Types.OSErr;
  888.     EXTERNAL PASCAL;
  889. PROCEDURE DDPCloseSocket*(theSocket: INTEGER): Types.OSErr;
  890.     EXTERNAL PASCAL;
  891. PROCEDURE DDPRead*(abRecord: ATDDPRecHandle; retCksumErrs: BOOLEAN; async: BOOLEAN): Types.OSErr;
  892.     EXTERNAL PASCAL;
  893. PROCEDURE DDPWrite*(abRecord: ATDDPRecHandle; doChecksum: BOOLEAN; async: BOOLEAN): Types.OSErr;
  894.     EXTERNAL PASCAL;
  895. PROCEDURE DDPRdCancel*(abRecord: ATDDPRecHandle): Types.OSErr;
  896.     EXTERNAL PASCAL;
  897. PROCEDURE ATPOpenSocket*(addrRcvd: AddrBlock; VAR atpSocket: INTEGER): Types.OSErr;
  898.     EXTERNAL PASCAL;
  899. PROCEDURE ATPCloseSocket*(atpSocket: INTEGER): Types.OSErr;
  900.     EXTERNAL PASCAL;
  901. PROCEDURE ATPSndRequest*(abRecord: ATATPRecHandle; async: BOOLEAN): Types.OSErr;
  902.     EXTERNAL PASCAL;
  903. PROCEDURE ATPRequest*(abRecord: ATATPRecHandle; async: BOOLEAN): Types.OSErr;
  904.     EXTERNAL PASCAL;
  905. PROCEDURE ATPReqCancel*(abRecord: ATATPRecHandle; async: BOOLEAN): Types.OSErr;
  906.     EXTERNAL PASCAL;
  907. PROCEDURE ATPGetRequest*(abRecord: ATATPRecHandle; async: BOOLEAN): Types.OSErr;
  908.     EXTERNAL PASCAL;
  909. PROCEDURE ATPSndRsp*(abRecord: ATATPRecHandle; async: BOOLEAN): Types.OSErr;
  910.     EXTERNAL PASCAL;
  911. PROCEDURE ATPAddRsp*(abRecord: ATATPRecHandle): Types.OSErr;
  912.     EXTERNAL PASCAL;
  913. PROCEDURE ATPResponse*(abRecord: ATATPRecHandle; async: BOOLEAN): Types.OSErr;
  914.     EXTERNAL PASCAL;
  915. PROCEDURE ATPRspCancel*(abRecord: ATATPRecHandle; async: BOOLEAN): Types.OSErr;
  916.     EXTERNAL PASCAL;
  917. PROCEDURE NBPRegister*(abRecord: ATNBPRecHandle; async: BOOLEAN): Types.OSErr;
  918.     EXTERNAL PASCAL;
  919. PROCEDURE NBPLookup*(abRecord: ATNBPRecHandle; async: BOOLEAN): Types.OSErr;
  920.     EXTERNAL PASCAL;
  921. PROCEDURE NBPConfirm*(abRecord: ATNBPRecHandle; async: BOOLEAN): Types.OSErr;
  922.     EXTERNAL PASCAL;
  923. PROCEDURE NBPRemove*(abEntity: EntityPtr): Types.OSErr;
  924.     EXTERNAL PASCAL;
  925. PROCEDURE NBPLoad*(): Types.OSErr;
  926.     EXTERNAL PASCAL;
  927. PROCEDURE NBPUnload*(): Types.OSErr;
  928.     EXTERNAL PASCAL;
  929. (*$END*)
  930.  
  931. (* $ALIGN RESET*)
  932. (* $POP*)
  933.  
  934.  END AppleTalk.
  935.